// 通用SQL关键词定义
export const COMMON_SQL_KEYWORDS = {
  // 基本关键词
  basic: [
    'SELECT', 'FROM', 'WHERE', 'INSERT', 'UPDATE', 'DELETE', 'CREATE', 'DROP', 'ALTER',
    'TABLE', 'INDEX', 'VIEW', 'DATABASE', 'SCHEMA', 'PROCEDURE', 'FUNCTION', 'TRIGGER',
    'AS', 'INTO', 'VALUES', 'SET'
  ],
  
  // 条件和逻辑
  conditions: [
    'AND', 'OR', 'NOT', 'IN', 'EXISTS', 'BETWEEN', 'LIKE', 'IS', 'NULL', 'TRUE', 'FALSE',
    'ANY', 'ALL', 'SOME'
  ],
  
  // 聚合和排序
  aggregation: [
    'GROUP BY', 'ORDER BY', 'HAVING', 'DISTINCT', 'COUNT', 'SUM', 'AVG', 'MIN', 'MAX',
    'LIMIT', 'OFFSET', 'TOP', 'FETCH', 'FIRST', 'NEXT', 'ROWS', 'ONLY'
  ],
  
  // 连接
  joins: [
    'JOIN', 'INNER JOIN', 'LEFT JOIN', 'RIGHT JOIN', 'FULL JOIN', 'CROSS JOIN', 'NATURAL JOIN',
    'ON', 'USING', 'OUTER', 'INNER', 'LEFT', 'RIGHT', 'FULL', 'CROSS'
  ],
  
  // 数据类型
  dataTypes: [
    'INT', 'INTEGER', 'VARCHAR', 'CHAR', 'TEXT', 'DATE', 'DATETIME', 'TIMESTAMP',
    'DECIMAL', 'FLOAT', 'DOUBLE', 'BOOLEAN', 'BLOB', 'JSON', 'BIGINT', 'SMALLINT',
    'TINYINT', 'REAL', 'BINARY', 'VARBINARY', 'ENUM', 'UUID'
  ],
  
  // 约束
  constraints: [
    'PRIMARY KEY', 'FOREIGN KEY', 'UNIQUE', 'NOT NULL', 'DEFAULT', 'CHECK', 'AUTO_INCREMENT',
    'IDENTITY', 'REFERENCES', 'CASCADE', 'RESTRICT', 'SET NULL', 'NO ACTION'
  ],
  
  // 事务
  transactions: [
    'BEGIN', 'COMMIT', 'ROLLBACK', 'TRANSACTION', 'SAVEPOINT', 'ISOLATION LEVEL',
    'READ COMMITTED', 'READ UNCOMMITTED', 'REPEATABLE READ', 'SERIALIZABLE'
  ],
  
  // 其他
  others: [
    'CASE', 'WHEN', 'THEN', 'ELSE', 'END', 'COALESCE', 'NULLIF', 'CAST', 'CONVERT',
    'UNION', 'UNION ALL', 'INTERSECT', 'EXCEPT', 'WITH', 'RECURSIVE', 'OVER', 'PARTITION BY',
    'IF', 'ELSE', 'WHILE', 'FOR', 'LOOP', 'RETURN', 'DECLARE', 'EXECUTE'
  ]
}

// 数据库特定关键词
export const DATABASE_SPECIFIC_KEYWORDS = {
  // MySQL 特有关键词
  mysql: {
    keywords: [
      'SHOW', 'DESCRIBE', 'EXPLAIN', 'USE', 'CHARSET', 'ENGINE', 'COLLATE', 'AUTO_INCREMENT',
      'UNSIGNED', 'ZEROFILL', 'TINYINT', 'MEDIUMINT', 'BIGINT', 'LONGTEXT', 'MEDIUMTEXT',
      'TINYTEXT', 'JSON', 'YEAR', 'SPATIAL', 'FULLTEXT', 'ALGORITHM', 'SQL_CACHE',
      'SQL_NO_CACHE', 'SQL_CALC_FOUND_ROWS', 'STRAIGHT_JOIN', 'ANALYZE', 'OPTIMIZE',
      'IGNORE', 'FORCE', 'DELAYED', 'LOW_PRIORITY', 'HIGH_PRIORITY', 'ON DUPLICATE KEY',
      'ROW_FORMAT', 'XA', 'REGEXP', 'RLIKE'
    ],
    functions: [
      'IFNULL', 'IF', 'NOW', 'CURDATE', 'CURTIME', 'DATE_FORMAT', 'STR_TO_DATE',
      'DATEDIFF', 'DATE_ADD', 'DATE_SUB', 'LAST_INSERT_ID', 'UUID', 'UUID_SHORT',
      'VERSION', 'DATABASE', 'USER', 'FOUND_ROWS', 'ROW_COUNT', 'CONCAT', 'CONCAT_WS',
      'GROUP_CONCAT', 'SUBSTRING_INDEX', 'INET_ATON', 'INET_NTOA', 'FIND_IN_SET',
      'REPLACE', 'INTERVAL', 'TIMESTAMPDIFF'
    ]
  },
  
  // PostgreSQL 特有关键词
  postgresql: {
    keywords: [
      'RETURNING', 'VARIADIC', 'ILIKE', 'SIMILAR TO', 'TABLESAMPLE', 'ONLY', 'LATERAL',
      'WINDOW', 'FILTER', 'EXCLUDE', 'GROUPS', 'ORDINALITY', 'XMLATTRIBUTES', 'XMLCONCAT',
      'XMLELEMENT', 'XMLFOREST', 'XMLNAMESPACES', 'XMLPARSE', 'XMLPI', 'XMLROOT', 'XMLSERIALIZE',
      'VACUUM', 'ANALYZE', 'NOTIFY', 'LISTEN', 'UNLISTEN', 'REINDEX', 'CONCURRENTLY',
      'TABLESPACE', 'LEAKPROOF', 'CALLED ON NULL INPUT', 'RETURNS NULL ON NULL INPUT',
      'STRICT', 'IMMUTABLE', 'STABLE', 'VOLATILE', 'COST'
    ],
    functions: [
      'ARRAY_AGG', 'ARRAY_APPEND', 'ARRAY_CAT', 'ARRAY_DIMS', 'ARRAY_FILL', 'ARRAY_LENGTH',
      'ARRAY_LOWER', 'ARRAY_POSITION', 'ARRAY_POSITIONS', 'ARRAY_PREPEND', 'ARRAY_REMOVE',
      'ARRAY_REPLACE', 'ARRAY_TO_STRING', 'ARRAY_UPPER', 'CURRENT_DATABASE', 'CURRENT_QUERY',
      'CURRENT_SCHEMA', 'GEN_RANDOM_UUID', 'TO_CHAR', 'TO_DATE', 'TO_NUMBER', 'TO_TIMESTAMP',
      'JSONB_ARRAY_ELEMENTS', 'JSONB_ARRAY_ELEMENTS_TEXT', 'JSONB_BUILD_ARRAY', 'JSONB_BUILD_OBJECT',
      'JSONB_OBJECT_KEYS', 'PG_ADVISORY_LOCK', 'PG_ADVISORY_UNLOCK', 'PG_SLEEP'
    ],
    types: [
      'BIGSERIAL', 'BIT VARYING', 'BOX', 'BYTEA', 'CIDR', 'CIRCLE', 'INET', 'INTERVAL',
      'JSON', 'JSONB', 'LINE', 'LSEG', 'MACADDR', 'MACADDR8', 'MONEY', 'PATH', 'PG_LSN',
      'POINT', 'POLYGON', 'SERIAL', 'SMALLSERIAL', 'TSQUERY', 'TSVECTOR', 'TXID_SNAPSHOT',
      'UUID', 'XML'
    ]
  },
  
  // SQL Server 特有关键词
  sqlserver: {
    keywords: [
      'TOP', 'OFFSET', 'FETCH', 'OUTPUT', 'OVER', 'TABLESAMPLE', 'PIVOT', 'UNPIVOT',
      'MERGE', 'HOLDLOCK', 'NOLOCK', 'NOWAIT', 'READCOMMITTED', 'READPAST', 'READUNCOMMITTED',
      'REPEATABLEREAD', 'ROWLOCK', 'SERIALIZABLE', 'TABLOCK', 'TABLOCKX', 'UPDLOCK', 'XLOCK',
      'TRY_CONVERT', 'THROW', 'IDENTITY', 'NONCLUSTERED', 'CLUSTERED', 'COLUMNSTORE',
      'FILESTREAM', 'FILLFACTOR', 'SPARSE', 'FILEGROUP', 'PERSISTED', 'INSTEAD OF',
      'WAITFOR', 'OPENDATASOURCE', 'OPENQUERY', 'OPENROWSET', 'OPENXML'
    ],
    functions: [
      'DATEADD', 'DATEDIFF', 'DATENAME', 'DATEPART', 'GETDATE', 'GETUTCDATE', 'ISDATE',
      'CONVERT', 'CAST', 'PARSE', 'TRY_CAST', 'TRY_CONVERT', 'TRY_PARSE', 'ISNULL',
      'COALESCE', 'NULLIF', 'NEWID', 'SCOPE_IDENTITY', 'SESSION_USER', 'SYSTEM_USER',
      'CURRENT_USER', 'CONCAT', 'STUFF', 'SUBSTRING', 'CHARINDEX', 'PATINDEX', 'LEN',
      'DATALENGTH', 'FORMAT', 'IIF', 'CHOOSE', 'ROW_NUMBER', 'RANK', 'DENSE_RANK',
      'NTILE', 'LEAD', 'LAG', 'FIRST_VALUE', 'LAST_VALUE'
    ],
    types: [
      'BIGINT', 'BIT', 'DECIMAL', 'MONEY', 'NUMERIC', 'SMALLINT', 'SMALLMONEY', 'TINYINT',
      'FLOAT', 'REAL', 'DATE', 'DATETIME2', 'DATETIME', 'DATETIMEOFFSET', 'SMALLDATETIME',
      'TIME', 'CHAR', 'VARCHAR', 'TEXT', 'NCHAR', 'NVARCHAR', 'NTEXT', 'BINARY', 'VARBINARY',
      'IMAGE', 'CURSOR', 'HIERARCHYID', 'SQL_VARIANT', 'TABLE', 'TIMESTAMP', 'UNIQUEIDENTIFIER',
      'XML', 'GEOGRAPHY', 'GEOMETRY'
    ]
  },
  
  // SQLite 特有关键词
  sqlite: {
    keywords: [
      'PRAGMA', 'VACUUM', 'ATTACH', 'DETACH', 'INSTEAD OF', 'INDEXED BY', 'NOT INDEXED',
      'REINDEX', 'CONFLICT', 'ABORT', 'FAIL', 'IGNORE', 'REPLACE', 'VIRTUAL', 'WITHOUT ROWID',
      'STRICT', 'RECURSIVE', 'AUTOINCREMENT', 'MATERIALIZED', 'GENERATED', 'ALWAYS', 'STORED',
      'VIRTUAL'
    ],
    functions: [
      'DATE', 'TIME', 'DATETIME', 'JULIANDAY', 'STRFTIME', 'CURRENT_DATE', 'CURRENT_TIME',
      'CURRENT_TIMESTAMP', 'RANDOM', 'RANDOMBLOB', 'ZEROBLOB', 'LAST_INSERT_ROWID',
      'TOTAL_CHANGES', 'CHANGES', 'CHAR', 'HEX', 'QUOTE', 'SOUNDEX', 'INSTR', 'REPLACE',
      'TRIM', 'LTRIM', 'RTRIM', 'LENGTH', 'TYPEOF', 'LIKELIHOOD', 'UNLIKELY', 'LIKELY'
    ],
    types: [
      'INTEGER', 'REAL', 'TEXT', 'BLOB', 'NUMERIC', 'BOOLEAN'
    ]
  },
  
  // Oracle 特有关键词
  oracle: {
    keywords: [
      'CONNECT BY', 'START WITH', 'PRIOR', 'NOCYCLE', 'LEVEL', 'CONNECT_BY_ROOT',
      'CONNECT_BY_ISLEAF', 'SYS_CONNECT_BY_PATH', 'VERSIONS', 'FLASHBACK', 'NOWAIT',
      'SAMPLE', 'MODEL', 'RULES', 'AUTOMATIC', 'SEQUENTIAL', 'MAIN', 'PARTITION BY',
      'DIMENSION BY', 'MEASURES', 'ITERATE', 'UNTIL', 'RULES', 'UPSERT', 'IGNORE NAV',
      'KEEP NAV', 'REFERENCE', 'RETURN', 'SINGLETON', 'CYCLE', 'NOCYCLE', 'ENABLE', 'DISABLE',
      'VALIDATE', 'NOVALIDATE', 'PARALLEL', 'NOPARALLEL'
    ],
    functions: [
      'DECODE', 'NVL', 'NVL2', 'NULLIF', 'GREATEST', 'LEAST', 'SYS_CONTEXT', 'UID',
      'USER', 'USERENV', 'SYSDATE', 'SYSTIMESTAMP', 'CURRENT_DATE', 'CURRENT_TIMESTAMP',
      'DBTIMEZONE', 'SESSIONTIMEZONE', 'EXTRACT', 'TO_CHAR', 'TO_DATE', 'TO_NUMBER',
      'TO_TIMESTAMP', 'ASCIISTR', 'BIN_TO_NUM', 'BITAND', 'CARDINALITY', 'COLLECT',
      'COMPOSE', 'CORR', 'COVAR_POP', 'COVAR_SAMP', 'CUME_DIST', 'DENSE_RANK', 'DEREF',
      'EMPTY_BLOB', 'EMPTY_CLOB', 'FIRST', 'GROUP_ID', 'GROUPING', 'GROUPING_ID', 'LAST',
      'LISTAGG', 'LNNVL', 'MEDIAN', 'ORA_HASH', 'PERCENT_RANK', 'PERCENTILE_CONT',
      'PERCENTILE_DISC', 'POWERMULTISET', 'POWERMULTISET_BY_CARDINALITY', 'RANK',
      'RATIO_TO_REPORT', 'REGEXP_COUNT', 'REGEXP_INSTR', 'REGEXP_REPLACE', 'REGEXP_SUBSTR',
      'REMAINDER', 'ROW_NUMBER', 'ROWIDTOCHAR', 'RPAD', 'RTRIM', 'SCN_TO_TIMESTAMP',
      'SESSIONTIMEZONE', 'STATS_BINOMIAL_TEST', 'STATS_CROSSTAB', 'STATS_F_TEST',
      'STATS_KS_TEST', 'STATS_MODE', 'STATS_MW_TEST', 'STATS_ONE_WAY_ANOVA', 'STATS_WSR_TEST',
      'STDDEV', 'STDDEV_POP', 'STDDEV_SAMP', 'SYS_CONNECT_BY_PATH', 'SYS_CONTEXT', 'SYS_DBURIGEN',
      'SYS_EXTRACT_UTC', 'SYS_GUID', 'SYS_TYPEID', 'SYS_XMLAGG', 'SYS_XMLGEN', 'TIMESTAMP_TO_SCN'
    ],
    types: [
      'NUMBER', 'FLOAT', 'BINARY_FLOAT', 'BINARY_DOUBLE', 'CHAR', 'VARCHAR2', 'NCHAR',
      'NVARCHAR2', 'CLOB', 'NCLOB', 'BLOB', 'BFILE', 'LONG', 'RAW', 'LONG RAW', 'ROWID',
      'UROWID', 'DATE', 'TIMESTAMP', 'TIMESTAMP WITH TIME ZONE', 'TIMESTAMP WITH LOCAL TIME ZONE',
      'INTERVAL YEAR TO MONTH', 'INTERVAL DAY TO SECOND', 'XMLType', 'URIType', 'ANYTYPE',
      'ANYDATA', 'ANYDATASET'
    ]
  }
}

// SQL关键词定义 - 向后兼容
export const SQL_KEYWORDS = {
  // 基本关键词
  basic: COMMON_SQL_KEYWORDS.basic,
  
  // 条件和逻辑
  conditions: COMMON_SQL_KEYWORDS.conditions,
  
  // 聚合和排序
  aggregation: COMMON_SQL_KEYWORDS.aggregation,
  
  // 连接
  joins: COMMON_SQL_KEYWORDS.joins,
  
  // 数据类型
  dataTypes: COMMON_SQL_KEYWORDS.dataTypes,
  
  // 约束
  constraints: COMMON_SQL_KEYWORDS.constraints
}

// 获取所有通用关键词
export const getAllCommonKeywords = () => {
  return Object.values(COMMON_SQL_KEYWORDS).flat()
}

// 获取特定数据库的关键词
export const getDatabaseKeywords = (dbType) => {
  if (!dbType || typeof dbType !== 'string') {
    return getAllCommonKeywords()
  }

  const dbTypeLower = dbType.toLowerCase()
  const specificDb = DATABASE_SPECIFIC_KEYWORDS[dbTypeLower]
  
  if (!specificDb) {
    return getAllCommonKeywords()
  }
  
  // 合并通用关键词和数据库特定关键词
  return [
    ...getAllCommonKeywords(),
    ...Object.values(specificDb).flat()
  ]
}

// 获取所有关键词（包括所有数据库的特定关键词）
export const getAllKeywords = () => {
  const allKeywords = new Set(getAllCommonKeywords())
  
  // 添加所有数据库特定关键词
  Object.values(DATABASE_SPECIFIC_KEYWORDS).forEach(dbKeywords => {
    Object.values(dbKeywords).forEach(categoryKeywords => {
      categoryKeywords.forEach(keyword => allKeywords.add(keyword))
    })
  })
  
  return Array.from(allKeywords)
}

// 检查是否为关键词
export const isKeyword = (word, dbType) => {
  if (!word || typeof word !== 'string') {
    return false
  }
  
  const upperWord = word.toUpperCase()
  
  if (dbType) {
    // 检查特定数据库的关键词
    return getDatabaseKeywords(dbType).some(keyword => 
      keyword.toUpperCase() === upperWord
    )
  } else {
    // 检查所有关键词
    return getAllKeywords().some(keyword => 
      keyword.toUpperCase() === upperWord
    )
  }
}

// 获取关键词类型
export const getKeywordType = (word) => {
  const upperWord = word.toUpperCase()
  
  // 先检查通用关键词
  for (const [type, keywords] of Object.entries(COMMON_SQL_KEYWORDS)) {
    if (keywords.some(k => k.toUpperCase() === upperWord)) {
      return type
    }
  }
  
  // 然后检查数据库特定关键词
  for (const [dbType, categories] of Object.entries(DATABASE_SPECIFIC_KEYWORDS)) {
    for (const [category, keywords] of Object.entries(categories)) {
      if (keywords.some(k => k.toUpperCase() === upperWord)) {
        return `${dbType}_${category}`
      }
    }
  }
  
  return null
}

export default {
  COMMON_SQL_KEYWORDS,
  DATABASE_SPECIFIC_KEYWORDS,
  SQL_KEYWORDS,
  getAllCommonKeywords,
  getDatabaseKeywords,
  getAllKeywords,
  isKeyword,
  getKeywordType
} 